/**
 * 格式化文件 - 回显
 * @param {*} val 文件数据
 * @param {string} fileKey 文件键名
 * @param {string} fileName 文件名键名
 * @returns {Array} 格式化后的文件列表
 */
export function formatFiles(val = [], fileKey = 'ossId', fileName = 'name') {
  if (!val) return [];
  const toFileObject = (item: Record<string, any>) => ({
    key: item[fileKey],
    name: item[fileName] || item['originalName'] || item['fileName'],
    uid: item[fileKey],
    ossId: item[fileKey],
    url: item?.url,
    status: 'done',
    response: {
      code: 200,
      data: {},
    },
  });
  return Array.isArray(val) ? val.map(toFileObject) : [toFileObject(val)];
}

/**
 * 字段映射函数（支持嵌套对象数组并保留原字段）
 * @param data 原始数据数组
 * @param fieldMap 字段映射配置，格式为 { 原字段名: 目标字段名 }
 * @param nestedField 指定嵌套字段名（例如 'children'）
 * @returns 转换后的数据数组
 */
interface DataItem {
  [key: string]: any;
  children?: DataItem[];
}
export function mapFields(
  data: DataItem[],
  fieldMap: Record<string, string>,
  nestedField: string = 'children',
): any[] {
  return Array.isArray(data)
    ? data?.map((item) => {
        // 创建一个新对象，拷贝所有原字段
        const mappedItem: DataItem = { ...item };
        // 添加映射字段
        for (const [sourceField, targetField] of Object.entries(fieldMap)) {
          if (item.hasOwnProperty(sourceField)) {
            (mappedItem as any)[targetField] = item[sourceField];
          }
        }
        // 递归处理嵌套字段
        if (
          item.hasOwnProperty(nestedField) &&
          Array.isArray(item[nestedField])
        ) {
          (mappedItem as any)[nestedField] = mapFields(
            item[nestedField] as DataItem[],
            fieldMap,
            nestedField,
          );
        }
        return mappedItem;
      })
    : [];
}

// 如果是负数，前面加‘负’
export function numberToChinese(num: string | number): string {
  let money = num.toString();
  let cnMoney = '零元整';
  let strOutput = '';
  let strUnit = '仟佰拾亿仟佰拾万仟佰拾元角分';
  money += '00';
  let intPos = money.indexOf('.');
  if (intPos >= 0) {
    money = money.substring(0, intPos) + money.substr(intPos + 1, 2);
  }
  strUnit = strUnit.substr(strUnit.length - money.length);
  for (let i = 0; i < money.length; i++) {
    strOutput +=
      '零壹贰叁肆伍陆柒捌玖'.charAt(parseInt(money.charAt(i))) +
      strUnit.charAt(i);
  }
  cnMoney = strOutput
    .replace(/零角零分$/, '整')
    .replace(/零[仟佰拾]/g, '零')
    .replace(/零{2,}/g, '零')
    .replace(/零([亿|万])/g, '$1')
    .replace(/零+元/, '元')
    .replace(/亿零{0,3}万/, '亿')
    .replace(/^元/, '零元');
  return cnMoney;
}

/**
 * 将对象映射转换为列表数组
 * @param {Record<string, any>} maps 要转换的对象映射，每个值应包含 label 属性
 * @param {'number' | string} keyType 键的类型，默认为 'string'。当为 'number' 时会尝试将键转换为数字
 * @returns {Array<{label: string, value: string | number, color?: string}>} 转换后的列表数组，每项包含 label、value 和可选的 color 属性
 */
export interface EnumItem {
  label: string;
  value: string | number;
  color?: string;
  [key: string]: any;
}
export const MapToList = (maps: Record<string, EnumItem>, keyType = 'string') =>
  Object.keys(maps).map((key: string) => {
    return {
      ...maps?.[key],
      label: maps?.[key]?.label,
      value: isNaN(Number(key)) ? key : keyType === 'number' ? +key : key,
      color: maps?.[key]?.color ?? '',
    };
  });
